home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / scripts / mod / modpost.c < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  54.5 KB  |  2,172 lines
  1. /* Postprocess module symbol versions
  2.  *
  3.  * Copyright 2003       Kai Germaschewski
  4.  * Copyright 2002-2004  Rusty Russell, IBM Corporation
  5.  * Copyright 2006-2008  Sam Ravnborg
  6.  * Based in part on module-init-tools/depmod.c,file2alias
  7.  *
  8.  * This software may be used and distributed according to the terms
  9.  * of the GNU General Public License, incorporated herein by reference.
  10.  *
  11.  * Usage: modpost vmlinux module1.o module2.o ...
  12.  */
  13.  
  14. #define _GNU_SOURCE
  15. #include <stdio.h>
  16. #include <ctype.h>
  17. #include "modpost.h"
  18. #include "../../include/linux/license.h"
  19.  
  20. /* Are we using CONFIG_MODVERSIONS? */
  21. int modversions = 0;
  22. /* Warn about undefined symbols? (do so if we have vmlinux) */
  23. int have_vmlinux = 0;
  24. /* Is CONFIG_MODULE_SRCVERSION_ALL set? */
  25. static int all_versions = 0;
  26. /* If we are modposting external module set to 1 */
  27. static int external_module = 0;
  28. /* Warn about section mismatch in vmlinux if set to 1 */
  29. static int vmlinux_section_warnings = 1;
  30. /* Only warn about unresolved symbols */
  31. static int warn_unresolved = 0;
  32. /* How a symbol is exported */
  33. static int sec_mismatch_count = 0;
  34. static int sec_mismatch_verbose = 1;
  35.  
  36. enum export {
  37.     export_plain,      export_unused,     export_gpl,
  38.     export_unused_gpl, export_gpl_future, export_unknown
  39. };
  40.  
  41. #define PRINTF __attribute__ ((format (printf, 1, 2)))
  42.  
  43. PRINTF void fatal(const char *fmt, ...)
  44. {
  45.     va_list arglist;
  46.  
  47.     fprintf(stderr, "FATAL: ");
  48.  
  49.     va_start(arglist, fmt);
  50.     vfprintf(stderr, fmt, arglist);
  51.     va_end(arglist);
  52.  
  53.     exit(1);
  54. }
  55.  
  56. PRINTF void warn(const char *fmt, ...)
  57. {
  58.     va_list arglist;
  59.  
  60.     fprintf(stderr, "WARNING: ");
  61.  
  62.     va_start(arglist, fmt);
  63.     vfprintf(stderr, fmt, arglist);
  64.     va_end(arglist);
  65. }
  66.  
  67. PRINTF void merror(const char *fmt, ...)
  68. {
  69.     va_list arglist;
  70.  
  71.     fprintf(stderr, "ERROR: ");
  72.  
  73.     va_start(arglist, fmt);
  74.     vfprintf(stderr, fmt, arglist);
  75.     va_end(arglist);
  76. }
  77.  
  78. static int is_vmlinux(const char *modname)
  79. {
  80.     const char *myname;
  81.  
  82.     myname = strrchr(modname, '/');
  83.     if (myname)
  84.         myname++;
  85.     else
  86.         myname = modname;
  87.  
  88.     return (strcmp(myname, "vmlinux") == 0) ||
  89.            (strcmp(myname, "vmlinux.o") == 0);
  90. }
  91.  
  92. void *do_nofail(void *ptr, const char *expr)
  93. {
  94.     if (!ptr)
  95.         fatal("modpost: Memory allocation failure: %s.\n", expr);
  96.  
  97.     return ptr;
  98. }
  99.  
  100. /* A list of all modules we processed */
  101. static struct module *modules;
  102.  
  103. static struct module *find_module(char *modname)
  104. {
  105.     struct module *mod;
  106.  
  107.     for (mod = modules; mod; mod = mod->next)
  108.         if (strcmp(mod->name, modname) == 0)
  109.             break;
  110.     return mod;
  111. }
  112.  
  113. static struct module *new_module(char *modname)
  114. {
  115.     struct module *mod;
  116.     char *p, *s;
  117.  
  118.     mod = NOFAIL(malloc(sizeof(*mod)));
  119.     memset(mod, 0, sizeof(*mod));
  120.     p = NOFAIL(strdup(modname));
  121.  
  122.     /* strip trailing .o */
  123.     s = strrchr(p, '.');
  124.     if (s != NULL)
  125.         if (strcmp(s, ".o") == 0)
  126.             *s = '\0';
  127.  
  128.     /* add to list */
  129.     mod->name = p;
  130.     mod->gpl_compatible = -1;
  131.     mod->next = modules;
  132.     modules = mod;
  133.  
  134.     return mod;
  135. }
  136.  
  137. /* A hash of all exported symbols,
  138.  * struct symbol is also used for lists of unresolved symbols */
  139.  
  140. #define SYMBOL_HASH_SIZE 1024
  141.  
  142. struct symbol {
  143.     struct symbol *next;
  144.     struct module *module;
  145.     unsigned int crc;
  146.     int crc_valid;
  147.     unsigned int weak:1;
  148.     unsigned int vmlinux:1;    /* 1 if symbol is defined in vmlinux */
  149.     unsigned int kernel:1;     /* 1 if symbol is from kernel
  150.                     *  (only for external modules) **/
  151.     unsigned int preloaded:1;  /* 1 if symbol from Module.symvers */
  152.     enum export  export;       /* Type of export */
  153.     char name[0];
  154. };
  155.  
  156. static struct symbol *symbolhash[SYMBOL_HASH_SIZE];
  157.  
  158. /* This is based on the hash agorithm from gdbm, via tdb */
  159. static inline unsigned int tdb_hash(const char *name)
  160. {
  161.     unsigned value;    /* Used to compute the hash value.  */
  162.     unsigned   i;    /* Used to cycle through random values. */
  163.  
  164.     /* Set the initial value from the key size. */
  165.     for (value = 0x238F13AF * strlen(name), i = 0; name[i]; i++)
  166.         value = (value + (((unsigned char *)name)[i] << (i*5 % 24)));
  167.  
  168.     return (1103515243 * value + 12345);
  169. }
  170.  
  171. /**
  172.  * Allocate a new symbols for use in the hash of exported symbols or
  173.  * the list of unresolved symbols per module
  174.  **/
  175. static struct symbol *alloc_symbol(const char *name, unsigned int weak,
  176.                    struct symbol *next)
  177. {
  178.     struct symbol *s = NOFAIL(malloc(sizeof(*s) + strlen(name) + 1));
  179.  
  180.     memset(s, 0, sizeof(*s));
  181.     strcpy(s->name, name);
  182.     s->weak = weak;
  183.     s->next = next;
  184.     return s;
  185. }
  186.  
  187. /* For the hash of exported symbols */
  188. static struct symbol *new_symbol(const char *name, struct module *module,
  189.                  enum export export)
  190. {
  191.     unsigned int hash;
  192.     struct symbol *new;
  193.  
  194.     hash = tdb_hash(name) % SYMBOL_HASH_SIZE;
  195.     new = symbolhash[hash] = alloc_symbol(name, 0, symbolhash[hash]);
  196.     new->module = module;
  197.     new->export = export;
  198.     return new;
  199. }
  200.  
  201. static struct symbol *find_symbol(const char *name)
  202. {
  203.     struct symbol *s;
  204.  
  205.     /* For our purposes, .foo matches foo.  PPC64 needs this. */
  206.     if (name[0] == '.')
  207.         name++;
  208.  
  209.     for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s = s->next) {
  210.         if (strcmp(s->name, name) == 0)
  211.             return s;
  212.     }
  213.     return NULL;
  214. }
  215.  
  216. static struct {
  217.     const char *str;
  218.     enum export export;
  219. } export_list[] = {
  220.     { .str = "EXPORT_SYMBOL",            .export = export_plain },
  221.     { .str = "EXPORT_UNUSED_SYMBOL",     .export = export_unused },
  222.     { .str = "EXPORT_SYMBOL_GPL",        .export = export_gpl },
  223.     { .str = "EXPORT_UNUSED_SYMBOL_GPL", .export = export_unused_gpl },
  224.     { .str = "EXPORT_SYMBOL_GPL_FUTURE", .export = export_gpl_future },
  225.     { .str = "(unknown)",                .export = export_unknown },
  226. };
  227.  
  228.  
  229. static const char *export_str(enum export ex)
  230. {
  231.     return export_list[ex].str;
  232. }
  233.  
  234. static enum export export_no(const char *s)
  235. {
  236.     int i;
  237.  
  238.     if (!s)
  239.         return export_unknown;
  240.     for (i = 0; export_list[i].export != export_unknown; i++) {
  241.         if (strcmp(export_list[i].str, s) == 0)
  242.             return export_list[i].export;
  243.     }
  244.     return export_unknown;
  245. }
  246.  
  247. static enum export export_from_sec(struct elf_info *elf, Elf_Section sec)
  248. {
  249.     if (sec == elf->export_sec)
  250.         return export_plain;
  251.     else if (sec == elf->export_unused_sec)
  252.         return export_unused;
  253.     else if (sec == elf->export_gpl_sec)
  254.         return export_gpl;
  255.     else if (sec == elf->export_unused_gpl_sec)
  256.         return export_unused_gpl;
  257.     else if (sec == elf->export_gpl_future_sec)
  258.         return export_gpl_future;
  259.     else
  260.         return export_unknown;
  261. }
  262.  
  263. /**
  264.  * Add an exported symbol - it may have already been added without a
  265.  * CRC, in this case just update the CRC
  266.  **/
  267. static struct symbol *sym_add_exported(const char *name, struct module *mod,
  268.                        enum export export)
  269. {
  270.     struct symbol *s = find_symbol(name);
  271.  
  272.     if (!s) {
  273.         s = new_symbol(name, mod, export);
  274.     } else {
  275.         if (!s->preloaded) {
  276.             warn("%s: '%s' exported twice. Previous export "
  277.                  "was in %s%s\n", mod->name, name,
  278.                  s->module->name,
  279.                  is_vmlinux(s->module->name) ?"":".ko");
  280.         } else {
  281.             /* In case Modules.symvers was out of date */
  282.             s->module = mod;
  283.         }
  284.     }
  285.     s->preloaded = 0;
  286.     s->vmlinux   = is_vmlinux(mod->name);
  287.     s->kernel    = 0;
  288.     s->export    = export;
  289.     return s;
  290. }
  291.  
  292. static void sym_update_crc(const char *name, struct module *mod,
  293.                unsigned int crc, enum export export)
  294. {
  295.     struct symbol *s = find_symbol(name);
  296.  
  297.     if (!s)
  298.         s = new_symbol(name, mod, export);
  299.     s->crc = crc;
  300.     s->crc_valid = 1;
  301. }
  302.  
  303. void *grab_file(const char *filename, unsigned long *size)
  304. {
  305.     struct stat st;
  306.     void *map;
  307.     int fd;
  308.  
  309.     fd = open(filename, O_RDONLY);
  310.     if (fd < 0 || fstat(fd, &st) != 0)
  311.         return NULL;
  312.  
  313.     *size = st.st_size;
  314.     map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
  315.     close(fd);
  316.  
  317.     if (map == MAP_FAILED)
  318.         return NULL;
  319.     return map;
  320. }
  321.  
  322. /**
  323.   * Return a copy of the next line in a mmap'ed file.
  324.   * spaces in the beginning of the line is trimmed away.
  325.   * Return a pointer to a static buffer.
  326.   **/
  327. char *get_next_line(unsigned long *pos, void *file, unsigned long size)
  328. {
  329.     static char line[4096];
  330.     int skip = 1;
  331.     size_t len = 0;
  332.     signed char *p = (signed char *)file + *pos;
  333.     char *s = line;
  334.  
  335.     for (; *pos < size ; (*pos)++) {
  336.         if (skip && isspace(*p)) {
  337.             p++;
  338.             continue;
  339.         }
  340.         skip = 0;
  341.         if (*p != '\n' && (*pos < size)) {
  342.             len++;
  343.             *s++ = *p++;
  344.             if (len > 4095)
  345.                 break; /* Too long, stop */
  346.         } else {
  347.             /* End of string */
  348.             *s = '\0';
  349.             return line;
  350.         }
  351.     }
  352.     /* End of buffer */
  353.     return NULL;
  354. }
  355.  
  356. void release_file(void *file, unsigned long size)
  357. {
  358.     munmap(file, size);
  359. }
  360.  
  361. static int parse_elf(struct elf_info *info, const char *filename)
  362. {
  363.     unsigned int i;
  364.     Elf_Ehdr *hdr;
  365.     Elf_Shdr *sechdrs;
  366.     Elf_Sym  *sym;
  367.  
  368.     hdr = grab_file(filename, &info->size);
  369.     if (!hdr) {
  370.         perror(filename);
  371.         exit(1);
  372.     }
  373.     info->hdr = hdr;
  374.     if (info->size < sizeof(*hdr)) {
  375.         /* file too small, assume this is an empty .o file */
  376.         return 0;
  377.     }
  378.     /* Is this a valid ELF file? */
  379.     if ((hdr->e_ident[EI_MAG0] != ELFMAG0) ||
  380.         (hdr->e_ident[EI_MAG1] != ELFMAG1) ||
  381.         (hdr->e_ident[EI_MAG2] != ELFMAG2) ||
  382.         (hdr->e_ident[EI_MAG3] != ELFMAG3)) {
  383.         /* Not an ELF file - silently ignore it */
  384.         return 0;
  385.     }
  386.     /* Fix endianness in ELF header */
  387.     hdr->e_shoff    = TO_NATIVE(hdr->e_shoff);
  388.     hdr->e_shstrndx = TO_NATIVE(hdr->e_shstrndx);
  389.     hdr->e_shnum    = TO_NATIVE(hdr->e_shnum);
  390.     hdr->e_machine  = TO_NATIVE(hdr->e_machine);
  391.     hdr->e_type     = TO_NATIVE(hdr->e_type);
  392.     sechdrs = (void *)hdr + hdr->e_shoff;
  393.     info->sechdrs = sechdrs;
  394.  
  395.     /* Check if file offset is correct */
  396.     if (hdr->e_shoff > info->size) {
  397.         fatal("section header offset=%lu in file '%s' is bigger than "
  398.               "filesize=%lu\n", (unsigned long)hdr->e_shoff,
  399.               filename, info->size);
  400.         return 0;
  401.     }
  402.  
  403.     /* Fix endianness in section headers */
  404.     for (i = 0; i < hdr->e_shnum; i++) {
  405.         sechdrs[i].sh_type   = TO_NATIVE(sechdrs[i].sh_type);
  406.         sechdrs[i].sh_offset = TO_NATIVE(sechdrs[i].sh_offset);
  407.         sechdrs[i].sh_size   = TO_NATIVE(sechdrs[i].sh_size);
  408.         sechdrs[i].sh_link   = TO_NATIVE(sechdrs[i].sh_link);
  409.         sechdrs[i].sh_name   = TO_NATIVE(sechdrs[i].sh_name);
  410.         sechdrs[i].sh_info   = TO_NATIVE(sechdrs[i].sh_info);
  411.         sechdrs[i].sh_addr   = TO_NATIVE(sechdrs[i].sh_addr);
  412.     }
  413.     /* Find symbol table. */
  414.     for (i = 1; i < hdr->e_shnum; i++) {
  415.         const char *secstrings
  416.             = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset;
  417.         const char *secname;
  418.  
  419.         if (sechdrs[i].sh_offset > info->size) {
  420.             fatal("%s is truncated. sechdrs[i].sh_offset=%lu > "
  421.                   "sizeof(*hrd)=%zu\n", filename,
  422.                   (unsigned long)sechdrs[i].sh_offset,
  423.                   sizeof(*hdr));
  424.             return 0;
  425.         }
  426.         secname = secstrings + sechdrs[i].sh_name;
  427.         if (strcmp(secname, ".modinfo") == 0) {
  428.             info->modinfo = (void *)hdr + sechdrs[i].sh_offset;
  429.             info->modinfo_len = sechdrs[i].sh_size;
  430.         } else if (strcmp(secname, "__ksymtab") == 0)
  431.             info->export_sec = i;
  432.         else if (strcmp(secname, "__ksymtab_unused") == 0)
  433.             info->export_unused_sec = i;
  434.         else if (strcmp(secname, "__ksymtab_gpl") == 0)
  435.             info->export_gpl_sec = i;
  436.         else if (strcmp(secname, "__ksymtab_unused_gpl") == 0)
  437.             info->export_unused_gpl_sec = i;
  438.         else if (strcmp(secname, "__ksymtab_gpl_future") == 0)
  439.             info->export_gpl_future_sec = i;
  440.         else if (strcmp(secname, "__markers_strings") == 0)
  441.             info->markers_strings_sec = i;
  442.  
  443.         if (sechdrs[i].sh_type != SHT_SYMTAB)
  444.             continue;
  445.  
  446.         info->symtab_start = (void *)hdr + sechdrs[i].sh_offset;
  447.         info->symtab_stop  = (void *)hdr + sechdrs[i].sh_offset
  448.                                      + sechdrs[i].sh_size;
  449.         info->strtab       = (void *)hdr +
  450.                          sechdrs[sechdrs[i].sh_link].sh_offset;
  451.     }
  452.     if (!info->symtab_start)
  453.         fatal("%s has no symtab?\n", filename);
  454.  
  455.     /* Fix endianness in symbols */
  456.     for (sym = info->symtab_start; sym < info->symtab_stop; sym++) {
  457.         sym->st_shndx = TO_NATIVE(sym->st_shndx);
  458.         sym->st_name  = TO_NATIVE(sym->st_name);
  459.         sym->st_value = TO_NATIVE(sym->st_value);
  460.         sym->st_size  = TO_NATIVE(sym->st_size);
  461.     }
  462.     return 1;
  463. }
  464.  
  465. static void parse_elf_finish(struct elf_info *info)
  466. {
  467.     release_file(info->hdr, info->size);
  468. }
  469.  
  470. static int ignore_undef_symbol(struct elf_info *info, const char *symname)
  471. {
  472.     /* ignore __this_module, it will be resolved shortly */
  473.     if (strcmp(symname, MODULE_SYMBOL_PREFIX "__this_module") == 0)
  474.         return 1;
  475.     /* ignore global offset table */
  476.     if (strcmp(symname, "_GLOBAL_OFFSET_TABLE_") == 0)
  477.         return 1;
  478.     if (info->hdr->e_machine == EM_PPC)
  479.         /* Special register function linked on all modules during final link of .ko */
  480.         if (strncmp(symname, "_restgpr_", sizeof("_restgpr_") - 1) == 0 ||
  481.             strncmp(symname, "_savegpr_", sizeof("_savegpr_") - 1) == 0 ||
  482.             strncmp(symname, "_rest32gpr_", sizeof("_rest32gpr_") - 1) == 0 ||
  483.             strncmp(symname, "_save32gpr_", sizeof("_save32gpr_") - 1) == 0)
  484.             return 1;
  485.     /* Do not ignore this symbol */
  486.     return 0;
  487. }
  488.  
  489. #define CRC_PFX     MODULE_SYMBOL_PREFIX "__crc_"
  490. #define KSYMTAB_PFX MODULE_SYMBOL_PREFIX "__ksymtab_"
  491.  
  492. static void handle_modversions(struct module *mod, struct elf_info *info,
  493.                    Elf_Sym *sym, const char *symname)
  494. {
  495.     unsigned int crc;
  496.     enum export export = export_from_sec(info, sym->st_shndx);
  497.  
  498.     switch (sym->st_shndx) {
  499.     case SHN_COMMON:
  500.         warn("\"%s\" [%s] is COMMON symbol\n", symname, mod->name);
  501.         break;
  502.     case SHN_ABS:
  503.         /* CRC'd symbol */
  504.         if (memcmp(symname, CRC_PFX, strlen(CRC_PFX)) == 0) {
  505.             crc = (unsigned int) sym->st_value;
  506.             sym_update_crc(symname + strlen(CRC_PFX), mod, crc,
  507.                     export);
  508.         }
  509.         break;
  510.     case SHN_UNDEF:
  511.         /* undefined symbol */
  512.         if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL &&
  513.             ELF_ST_BIND(sym->st_info) != STB_WEAK)
  514.             break;
  515.         if (ignore_undef_symbol(info, symname))
  516.             break;
  517. /* cope with newer glibc (2.3.4 or higher) STT_ definition in elf.h */
  518. #if defined(STT_REGISTER) || defined(STT_SPARC_REGISTER)
  519. /* add compatibility with older glibc */
  520. #ifndef STT_SPARC_REGISTER
  521. #define STT_SPARC_REGISTER STT_REGISTER
  522. #endif
  523.         if (info->hdr->e_machine == EM_SPARC ||
  524.             info->hdr->e_machine == EM_SPARCV9) {
  525.             /* Ignore register directives. */
  526.             if (ELF_ST_TYPE(sym->st_info) == STT_SPARC_REGISTER)
  527.                 break;
  528.             if (symname[0] == '.') {
  529.                 char *munged = strdup(symname);
  530.                 munged[0] = '_';
  531.                 munged[1] = toupper(munged[1]);
  532.                 symname = munged;
  533.             }
  534.         }
  535. #endif
  536.  
  537.         if (memcmp(symname, MODULE_SYMBOL_PREFIX,
  538.                strlen(MODULE_SYMBOL_PREFIX)) == 0) {
  539.             mod->unres =
  540.               alloc_symbol(symname +
  541.                            strlen(MODULE_SYMBOL_PREFIX),
  542.                            ELF_ST_BIND(sym->st_info) == STB_WEAK,
  543.                            mod->unres);
  544.         }
  545.         break;
  546.     default:
  547.         /* All exported symbols */
  548.         if (memcmp(symname, KSYMTAB_PFX, strlen(KSYMTAB_PFX)) == 0) {
  549.             sym_add_exported(symname + strlen(KSYMTAB_PFX), mod,
  550.                     export);
  551.         }
  552.         if (strcmp(symname, MODULE_SYMBOL_PREFIX "init_module") == 0)
  553.             mod->has_init = 1;
  554.         if (strcmp(symname, MODULE_SYMBOL_PREFIX "cleanup_module") == 0)
  555.             mod->has_cleanup = 1;
  556.         break;
  557.     }
  558. }
  559.  
  560. /**
  561.  * Parse tag=value strings from .modinfo section
  562.  **/
  563. static char *next_string(char *string, unsigned long *secsize)
  564. {
  565.     /* Skip non-zero chars */
  566.     while (string[0]) {
  567.         string++;
  568.         if ((*secsize)-- <= 1)
  569.             return NULL;
  570.     }
  571.  
  572.     /* Skip any zero padding. */
  573.     while (!string[0]) {
  574.         string++;
  575.         if ((*secsize)-- <= 1)
  576.             return NULL;
  577.     }
  578.     return string;
  579. }
  580.  
  581. static char *get_next_modinfo(void *modinfo, unsigned long modinfo_len,
  582.                   const char *tag, char *info)
  583. {
  584.     char *p;
  585.     unsigned int taglen = strlen(tag);
  586.     unsigned long size = modinfo_len;
  587.  
  588.     if (info) {
  589.         size -= info - (char *)modinfo;
  590.         modinfo = next_string(info, &size);
  591.     }
  592.  
  593.     for (p = modinfo; p; p = next_string(p, &size)) {
  594.         if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
  595.             return p + taglen + 1;
  596.     }
  597.     return NULL;
  598. }
  599.  
  600. static char *get_modinfo(void *modinfo, unsigned long modinfo_len,
  601.              const char *tag)
  602.  
  603. {
  604.     return get_next_modinfo(modinfo, modinfo_len, tag, NULL);
  605. }
  606.  
  607. /**
  608.  * Test if string s ends in string sub
  609.  * return 0 if match
  610.  **/
  611. static int strrcmp(const char *s, const char *sub)
  612. {
  613.     int slen, sublen;
  614.  
  615.     if (!s || !sub)
  616.         return 1;
  617.  
  618.     slen = strlen(s);
  619.     sublen = strlen(sub);
  620.  
  621.     if ((slen == 0) || (sublen == 0))
  622.         return 1;
  623.  
  624.     if (sublen > slen)
  625.         return 1;
  626.  
  627.     return memcmp(s + slen - sublen, sub, sublen);
  628. }
  629.  
  630. static const char *sym_name(struct elf_info *elf, Elf_Sym *sym)
  631. {
  632.     if (sym)
  633.         return elf->strtab + sym->st_name;
  634.     else
  635.         return "(unknown)";
  636. }
  637.  
  638. static const char *sec_name(struct elf_info *elf, int shndx)
  639. {
  640.     Elf_Shdr *sechdrs = elf->sechdrs;
  641.     return (void *)elf->hdr +
  642.             elf->sechdrs[elf->hdr->e_shstrndx].sh_offset +
  643.             sechdrs[shndx].sh_name;
  644. }
  645.  
  646. static const char *sech_name(struct elf_info *elf, Elf_Shdr *sechdr)
  647. {
  648.     return (void *)elf->hdr +
  649.             elf->sechdrs[elf->hdr->e_shstrndx].sh_offset +
  650.             sechdr->sh_name;
  651. }
  652.  
  653. /* if sym is empty or point to a string
  654.  * like ".[0-9]+" then return 1.
  655.  * This is the optional prefix added by ld to some sections
  656.  */
  657. static int number_prefix(const char *sym)
  658. {
  659.     if (*sym++ == '\0')
  660.         return 1;
  661.     if (*sym != '.')
  662.         return 0;
  663.     do {
  664.         char c = *sym++;
  665.         if (c < '0' || c > '9')
  666.             return 0;
  667.     } while (*sym);
  668.     return 1;
  669. }
  670.  
  671. /* The pattern is an array of simple patterns.
  672.  * "foo" will match an exact string equal to "foo"
  673.  * "*foo" will match a string that ends with "foo"
  674.  * "foo*" will match a string that begins with "foo"
  675.  * "foo$" will match a string equal to "foo" or "foo.1"
  676.  *   where the '1' can be any number including several digits.
  677.  *   The $ syntax is for sections where ld append a dot number
  678.  *   to make section name unique.
  679.  */
  680. int match(const char *sym, const char * const pat[])
  681. {
  682.     const char *p;
  683.     while (*pat) {
  684.         p = *pat++;
  685.         const char *endp = p + strlen(p) - 1;
  686.  
  687.         /* "*foo" */
  688.         if (*p == '*') {
  689.             if (strrcmp(sym, p + 1) == 0)
  690.                 return 1;
  691.         }
  692.         /* "foo*" */
  693.         else if (*endp == '*') {
  694.             if (strncmp(sym, p, strlen(p) - 1) == 0)
  695.                 return 1;
  696.         }
  697.         /* "foo$" */
  698.         else if (*endp == '$') {
  699.             if (strncmp(sym, p, strlen(p) - 1) == 0) {
  700.                 if (number_prefix(sym + strlen(p) - 1))
  701.                     return 1;
  702.             }
  703.         }
  704.         /* no wildcards */
  705.         else {
  706.             if (strcmp(p, sym) == 0)
  707.                 return 1;
  708.         }
  709.     }
  710.     /* no match */
  711.     return 0;
  712. }
  713.  
  714. /* sections that we do not want to do full section mismatch check on */
  715. static const char *section_white_list[] =
  716.     { ".debug*", ".stab*", ".note*", ".got*", ".toc*", NULL };
  717.  
  718. /*
  719.  * Is this section one we do not want to check?
  720.  * This is often debug sections.
  721.  * If we are going to check this section then
  722.  * test if section name ends with a dot and a number.
  723.  * This is used to find sections where the linker have
  724.  * appended a dot-number to make the name unique.
  725.  * The cause of this is often a section specified in assembler
  726.  * without "ax" / "aw" and the same section used in .c
  727.  * code where gcc add these.
  728.  */
  729. static int check_section(const char *modname, const char *sec)
  730. {
  731.     const char *e = sec + strlen(sec) - 1;
  732.     if (match(sec, section_white_list))
  733.         return 1;
  734.  
  735.     if (*e && isdigit(*e)) {
  736.         /* consume all digits */
  737.         while (*e && e != sec && isdigit(*e))
  738.             e--;
  739.         if (*e == '.' && !strstr(sec, ".linkonce")) {
  740.             warn("%s (%s): unexpected section name.\n"
  741.                  "The (.[number]+) following section name are "
  742.                  "ld generated and not expected.\n"
  743.                  "Did you forget to use \"ax\"/\"aw\" "
  744.                  "in a .S file?\n"
  745.                  "Note that for example <linux/init.h> contains\n"
  746.                  "section definitions for use in .S files.\n\n",
  747.                  modname, sec);
  748.         }
  749.     }
  750.     return 0;
  751. }
  752.  
  753.  
  754.  
  755. #define ALL_INIT_DATA_SECTIONS \
  756.     ".init.data$", ".devinit.data$", ".cpuinit.data$", ".meminit.data$"
  757. #define ALL_EXIT_DATA_SECTIONS \
  758.     ".exit.data$", ".devexit.data$", ".cpuexit.data$", ".memexit.data$"
  759.  
  760. #define ALL_INIT_TEXT_SECTIONS \
  761.     ".init.text$", ".devinit.text$", ".cpuinit.text$", ".meminit.text$"
  762. #define ALL_EXIT_TEXT_SECTIONS \
  763.     ".exit.text$", ".devexit.text$", ".cpuexit.text$", ".memexit.text$"
  764.  
  765. #define ALL_INIT_SECTIONS ALL_INIT_DATA_SECTIONS, ALL_INIT_TEXT_SECTIONS
  766. #define ALL_EXIT_SECTIONS ALL_EXIT_DATA_SECTIONS, ALL_EXIT_TEXT_SECTIONS
  767.  
  768. #define DATA_SECTIONS ".data$", ".data.rel$"
  769. #define TEXT_SECTIONS ".text$"
  770.  
  771. #define INIT_SECTIONS      ".init.data$", ".init.text$"
  772. #define DEV_INIT_SECTIONS  ".devinit.data$", ".devinit.text$"
  773. #define CPU_INIT_SECTIONS  ".cpuinit.data$", ".cpuinit.text$"
  774. #define MEM_INIT_SECTIONS  ".meminit.data$", ".meminit.text$"
  775.  
  776. #define EXIT_SECTIONS      ".exit.data$", ".exit.text$"
  777. #define DEV_EXIT_SECTIONS  ".devexit.data$", ".devexit.text$"
  778. #define CPU_EXIT_SECTIONS  ".cpuexit.data$", ".cpuexit.text$"
  779. #define MEM_EXIT_SECTIONS  ".memexit.data$", ".memexit.text$"
  780.  
  781. /* init data sections */
  782. static const char *init_data_sections[] = { ALL_INIT_DATA_SECTIONS, NULL };
  783.  
  784. /* all init sections */
  785. static const char *init_sections[] = { ALL_INIT_SECTIONS, NULL };
  786.  
  787. /* All init and exit sections (code + data) */
  788. static const char *init_exit_sections[] =
  789.     {ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL };
  790.  
  791. /* data section */
  792. static const char *data_sections[] = { DATA_SECTIONS, NULL };
  793.  
  794. /* sections that may refer to an init/exit section with no warning */
  795. static const char *initref_sections[] =
  796. {
  797.     ".text.init.refok*",
  798.     ".exit.text.refok*",
  799.     ".data.init.refok*",
  800.     NULL
  801. };
  802.  
  803.  
  804. /* symbols in .data that may refer to init/exit sections */
  805. static const char *symbol_white_list[] =
  806. {
  807.     "*driver",
  808.     "*_template", /* scsi uses *_template a lot */
  809.     "*_timer",    /* arm uses ops structures named _timer a lot */
  810.     "*_sht",      /* scsi also used *_sht to some extent */
  811.     "*_ops",
  812.     "*_probe",
  813.     "*_probe_one",
  814.     "*_console",
  815.     NULL
  816. };
  817.  
  818. static const char *head_sections[] = { ".head.text*", NULL };
  819. static const char *linker_symbols[] =
  820.     { "__init_begin", "_sinittext", "_einittext", NULL };
  821.  
  822. enum mismatch {
  823.     NO_MISMATCH,
  824.     TEXT_TO_INIT,
  825.     DATA_TO_INIT,
  826.     TEXT_TO_EXIT,
  827.     DATA_TO_EXIT,
  828.     XXXINIT_TO_INIT,
  829.     XXXEXIT_TO_EXIT,
  830.     INIT_TO_EXIT,
  831.     EXIT_TO_INIT,
  832.     EXPORT_TO_INIT_EXIT,
  833. };
  834.  
  835. struct sectioncheck {
  836.     const char *fromsec[20];
  837.     const char *tosec[20];
  838.     enum mismatch mismatch;
  839. };
  840.  
  841. const struct sectioncheck sectioncheck[] = {
  842. /* Do not reference init/exit code/data from
  843.  * normal code and data
  844.  */
  845. {
  846.     .fromsec = { TEXT_SECTIONS, NULL },
  847.     .tosec   = { ALL_INIT_SECTIONS, NULL },
  848.     .mismatch = TEXT_TO_INIT,
  849. },
  850. {
  851.     .fromsec = { DATA_SECTIONS, NULL },
  852.     .tosec   = { ALL_INIT_SECTIONS, NULL },
  853.     .mismatch = DATA_TO_INIT,
  854. },
  855. {
  856.     .fromsec = { TEXT_SECTIONS, NULL },
  857.     .tosec   = { ALL_EXIT_SECTIONS, NULL },
  858.     .mismatch = TEXT_TO_EXIT,
  859. },
  860. {
  861.     .fromsec = { DATA_SECTIONS, NULL },
  862.     .tosec   = { ALL_EXIT_SECTIONS, NULL },
  863.     .mismatch = DATA_TO_EXIT,
  864. },
  865. /* Do not reference init code/data from devinit/cpuinit/meminit code/data */
  866. {
  867.     .fromsec = { DEV_INIT_SECTIONS, CPU_INIT_SECTIONS, MEM_INIT_SECTIONS, NULL },
  868.     .tosec   = { INIT_SECTIONS, NULL },
  869.     .mismatch = XXXINIT_TO_INIT,
  870. },
  871. /* Do not reference exit code/data from devexit/cpuexit/memexit code/data */
  872. {
  873.     .fromsec = { DEV_EXIT_SECTIONS, CPU_EXIT_SECTIONS, MEM_EXIT_SECTIONS, NULL },
  874.     .tosec   = { EXIT_SECTIONS, NULL },
  875.     .mismatch = XXXEXIT_TO_EXIT,
  876. },
  877. /* Do not use exit code/data from init code */
  878. {
  879.     .fromsec = { ALL_INIT_SECTIONS, NULL },
  880.     .tosec   = { ALL_EXIT_SECTIONS, NULL },
  881.     .mismatch = INIT_TO_EXIT,
  882. },
  883. /* Do not use init code/data from exit code */
  884. {
  885.     .fromsec = { ALL_EXIT_SECTIONS, NULL },
  886.     .tosec   = { ALL_INIT_SECTIONS, NULL },
  887.     .mismatch = EXIT_TO_INIT,
  888. },
  889. /* Do not export init/exit functions or data */
  890. {
  891.     .fromsec = { "__ksymtab*", NULL },
  892.     .tosec   = { INIT_SECTIONS, EXIT_SECTIONS, NULL },
  893.     .mismatch = EXPORT_TO_INIT_EXIT
  894. }
  895. };
  896.  
  897. static int section_mismatch(const char *fromsec, const char *tosec)
  898. {
  899.     int i;
  900.     int elems = sizeof(sectioncheck) / sizeof(struct sectioncheck);
  901.     const struct sectioncheck *check = §ioncheck[0];
  902.  
  903.     for (i = 0; i < elems; i++) {
  904.         if (match(fromsec, check->fromsec) &&
  905.             match(tosec, check->tosec))
  906.             return check->mismatch;
  907.         check++;
  908.     }
  909.     return NO_MISMATCH;
  910. }
  911.  
  912. /**
  913.  * Whitelist to allow certain references to pass with no warning.
  914.  *
  915.  * Pattern 0:
  916.  *   Do not warn if funtion/data are marked with __init_refok/__initdata_refok.
  917.  *   The pattern is identified by:
  918.  *   fromsec = .text.init.refok* | .data.init.refok*
  919.  *
  920.  * Pattern 1:
  921.  *   If a module parameter is declared __initdata and permissions=0
  922.  *   then this is legal despite the warning generated.
  923.  *   We cannot see value of permissions here, so just ignore
  924.  *   this pattern.
  925.  *   The pattern is identified by:
  926.  *   tosec   = .init.data
  927.  *   fromsec = .data*
  928.  *   atsym   =__param*
  929.  *
  930.  * Pattern 2:
  931.  *   Many drivers utilise a *driver container with references to
  932.  *   add, remove, probe functions etc.
  933.  *   These functions may often be marked __init and we do not want to
  934.  *   warn here.
  935.  *   the pattern is identified by:
  936.  *   tosec   = init or exit section
  937.  *   fromsec = data section
  938.  *   atsym = *driver, *_template, *_sht, *_ops, *_probe,
  939.  *           *probe_one, *_console, *_timer
  940.  *
  941.  * Pattern 3:
  942.  *   Whitelist all refereces from .text.head to .init.data
  943.  *   Whitelist all refereces from .text.head to .init.text
  944.  *
  945.  * Pattern 4:
  946.  *   Some symbols belong to init section but still it is ok to reference
  947.  *   these from non-init sections as these symbols don't have any memory
  948.  *   allocated for them and symbol address and value are same. So even
  949.  *   if init section is freed, its ok to reference those symbols.
  950.  *   For ex. symbols marking the init section boundaries.
  951.  *   This pattern is identified by
  952.  *   refsymname = __init_begin, _sinittext, _einittext
  953.  *
  954.  **/
  955. static int secref_whitelist(const char *fromsec, const char *fromsym,
  956.                 const char *tosec, const char *tosym)
  957. {
  958.     /* Check for pattern 0 */
  959.     if (match(fromsec, initref_sections))
  960.         return 0;
  961.  
  962.     /* Check for pattern 1 */
  963.     if (match(tosec, init_data_sections) &&
  964.         match(fromsec, data_sections) &&
  965.         (strncmp(fromsym, "__param", strlen("__param")) == 0))
  966.         return 0;
  967.  
  968.     /* Check for pattern 2 */
  969.     if (match(tosec, init_exit_sections) &&
  970.         match(fromsec, data_sections) &&
  971.         match(fromsym, symbol_white_list))
  972.         return 0;
  973.  
  974.     /* Check for pattern 3 */
  975.     if (match(fromsec, head_sections) &&
  976.         match(tosec, init_sections))
  977.         return 0;
  978.  
  979.     /* Check for pattern 4 */
  980.     if (match(tosym, linker_symbols))
  981.         return 0;
  982.  
  983.     return 1;
  984. }
  985.  
  986. /**
  987.  * Find symbol based on relocation record info.
  988.  * In some cases the symbol supplied is a valid symbol so
  989.  * return refsym. If st_name != 0 we assume this is a valid symbol.
  990.  * In other cases the symbol needs to be looked up in the symbol table
  991.  * based on section and address.
  992.  *  **/
  993. static Elf_Sym *find_elf_symbol(struct elf_info *elf, Elf64_Sword addr,
  994.                 Elf_Sym *relsym)
  995. {
  996.     Elf_Sym *sym;
  997.     Elf_Sym *near = NULL;
  998.     Elf64_Sword distance = 20;
  999.     Elf64_Sword d;
  1000.  
  1001.     if (relsym->st_name != 0)
  1002.         return relsym;
  1003.     for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
  1004.         if (sym->st_shndx != relsym->st_shndx)
  1005.             continue;
  1006.         if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
  1007.             continue;
  1008.         if (sym->st_value == addr)
  1009.             return sym;
  1010.         /* Find a symbol nearby - addr are maybe negative */
  1011.         d = sym->st_value - addr;
  1012.         if (d < 0)
  1013.             d = addr - sym->st_value;
  1014.         if (d < distance) {
  1015.             distance = d;
  1016.             near = sym;
  1017.         }
  1018.     }
  1019.     /* We need a close match */
  1020.     if (distance < 20)
  1021.         return near;
  1022.     else
  1023.         return NULL;
  1024. }
  1025.  
  1026. static inline int is_arm_mapping_symbol(const char *str)
  1027. {
  1028.     return str[0] == '$' && strchr("atd", str[1])
  1029.            && (str[2] == '\0' || str[2] == '.');
  1030. }
  1031.  
  1032. /*
  1033.  * If there's no name there, ignore it; likewise, ignore it if it's
  1034.  * one of the magic symbols emitted used by current ARM tools.
  1035.  *
  1036.  * Otherwise if find_symbols_between() returns those symbols, they'll
  1037.  * fail the whitelist tests and cause lots of false alarms ... fixable
  1038.  * only by merging __exit and __init sections into __text, bloating
  1039.  * the kernel (which is especially evil on embedded platforms).
  1040.  */
  1041. static inline int is_valid_name(struct elf_info *elf, Elf_Sym *sym)
  1042. {
  1043.     const char *name = elf->strtab + sym->st_name;
  1044.  
  1045.     if (!name || !strlen(name))
  1046.         return 0;
  1047.     return !is_arm_mapping_symbol(name);
  1048. }
  1049.  
  1050. /*
  1051.  * Find symbols before or equal addr and after addr - in the section sec.
  1052.  * If we find two symbols with equal offset prefer one with a valid name.
  1053.  * The ELF format may have a better way to detect what type of symbol
  1054.  * it is, but this works for now.
  1055.  **/
  1056. static Elf_Sym *find_elf_symbol2(struct elf_info *elf, Elf_Addr addr,
  1057.                  const char *sec)
  1058. {
  1059.     Elf_Sym *sym;
  1060.     Elf_Sym *near = NULL;
  1061.     Elf_Addr distance = ~0;
  1062.  
  1063.     for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
  1064.         const char *symsec;
  1065.  
  1066.         if (sym->st_shndx >= SHN_LORESERVE)
  1067.             continue;
  1068.         symsec = sec_name(elf, sym->st_shndx);
  1069.         if (strcmp(symsec, sec) != 0)
  1070.             continue;
  1071.         if (!is_valid_name(elf, sym))
  1072.             continue;
  1073.         if (sym->st_value <= addr) {
  1074.             if ((addr - sym->st_value) < distance) {
  1075.                 distance = addr - sym->st_value;
  1076.                 near = sym;
  1077.             } else if ((addr - sym->st_value) == distance) {
  1078.                 near = sym;
  1079.             }
  1080.         }
  1081.     }
  1082.     return near;
  1083. }
  1084.  
  1085. /*
  1086.  * Convert a section name to the function/data attribute
  1087.  * .init.text => __init
  1088.  * .cpuinit.data => __cpudata
  1089.  * .memexitconst => __memconst
  1090.  * etc.
  1091. */
  1092. static char *sec2annotation(const char *s)
  1093. {
  1094.     if (match(s, init_exit_sections)) {
  1095.         char *p = malloc(20);
  1096.         char *r = p;
  1097.  
  1098.         *p++ = '_';
  1099.         *p++ = '_';
  1100.         if (*s == '.')
  1101.             s++;
  1102.         while (*s && *s != '.')
  1103.             *p++ = *s++;
  1104.         *p = '\0';
  1105.         if (*s == '.')
  1106.             s++;
  1107.         if (strstr(s, "rodata") != NULL)
  1108.             strcat(p, "const ");
  1109.         else if (strstr(s, "data") != NULL)
  1110.             strcat(p, "data ");
  1111.         else
  1112.             strcat(p, " ");
  1113.         return r; /* we leak her but we do not care */
  1114.     } else {
  1115.         return "";
  1116.     }
  1117. }
  1118.  
  1119. static int is_function(Elf_Sym *sym)
  1120. {
  1121.     if (sym)
  1122.         return ELF_ST_TYPE(sym->st_info) == STT_FUNC;
  1123.     else
  1124.         return -1;
  1125. }
  1126.  
  1127. /*
  1128.  * Print a warning about a section mismatch.
  1129.  * Try to find symbols near it so user can find it.
  1130.  * Check whitelist before warning - it may be a false positive.
  1131.  */
  1132. static void report_sec_mismatch(const char *modname, enum mismatch mismatch,
  1133.                                 const char *fromsec,
  1134.                                 unsigned long long fromaddr,
  1135.                                 const char *fromsym,
  1136.                                 int from_is_func,
  1137.                                 const char *tosec, const char *tosym,
  1138.                                 int to_is_func)
  1139. {
  1140.     const char *from, *from_p;
  1141.     const char *to, *to_p;
  1142.  
  1143.     switch (from_is_func) {
  1144.     case 0: from = "variable"; from_p = "";   break;
  1145.     case 1: from = "function"; from_p = "()"; break;
  1146.     default: from = "(unknown reference)"; from_p = ""; break;
  1147.     }
  1148.     switch (to_is_func) {
  1149.     case 0: to = "variable"; to_p = "";   break;
  1150.     case 1: to = "function"; to_p = "()"; break;
  1151.     default: to = "(unknown reference)"; to_p = ""; break;
  1152.     }
  1153.  
  1154.     sec_mismatch_count++;
  1155.     if (!sec_mismatch_verbose)
  1156.         return;
  1157.  
  1158.     warn("%s(%s+0x%llx): Section mismatch in reference from the %s %s%s "
  1159.          "to the %s %s:%s%s\n",
  1160.          modname, fromsec, fromaddr, from, fromsym, from_p, to, tosec,
  1161.          tosym, to_p);
  1162.  
  1163.     switch (mismatch) {
  1164.     case TEXT_TO_INIT:
  1165.         fprintf(stderr,
  1166.         "The function %s%s() references\n"
  1167.         "the %s %s%s%s.\n"
  1168.         "This is often because %s lacks a %s\n"
  1169.         "annotation or the annotation of %s is wrong.\n",
  1170.         sec2annotation(fromsec), fromsym,
  1171.         to, sec2annotation(tosec), tosym, to_p,
  1172.         fromsym, sec2annotation(tosec), tosym);
  1173.         break;
  1174.     case DATA_TO_INIT: {
  1175.         const char **s = symbol_white_list;
  1176.         fprintf(stderr,
  1177.         "The variable %s references\n"
  1178.         "the %s %s%s%s\n"
  1179.         "If the reference is valid then annotate the\n"
  1180.         "variable with __init* (see linux/init.h) "
  1181.         "or name the variable:\n",
  1182.         fromsym, to, sec2annotation(tosec), tosym, to_p);
  1183.         while (*s)
  1184.             fprintf(stderr, "%s, ", *s++);
  1185.         fprintf(stderr, "\n");
  1186.         break;
  1187.     }
  1188.     case TEXT_TO_EXIT:
  1189.         fprintf(stderr,
  1190.         "The function %s() references a %s in an exit section.\n"
  1191.         "Often the %s %s%s has valid usage outside the exit section\n"
  1192.         "and the fix is to remove the %sannotation of %s.\n",
  1193.         fromsym, to, to, tosym, to_p, sec2annotation(tosec), tosym);
  1194.         break;
  1195.     case DATA_TO_EXIT: {
  1196.         const char **s = symbol_white_list;
  1197.         fprintf(stderr,
  1198.         "The variable %s references\n"
  1199.         "the %s %s%s%s\n"
  1200.         "If the reference is valid then annotate the\n"
  1201.         "variable with __exit* (see linux/init.h) or "
  1202.         "name the variable:\n",
  1203.         fromsym, to, sec2annotation(tosec), tosym, to_p);
  1204.         while (*s)
  1205.             fprintf(stderr, "%s, ", *s++);
  1206.         fprintf(stderr, "\n");
  1207.         break;
  1208.     }
  1209.     case XXXINIT_TO_INIT:
  1210.     case XXXEXIT_TO_EXIT:
  1211.         fprintf(stderr,
  1212.         "The %s %s%s%s references\n"
  1213.         "a %s %s%s%s.\n"
  1214.         "If %s is only used by %s then\n"
  1215.         "annotate %s with a matching annotation.\n",
  1216.         from, sec2annotation(fromsec), fromsym, from_p,
  1217.         to, sec2annotation(tosec), tosym, to_p,
  1218.         tosym, fromsym, tosym);
  1219.         break;
  1220.     case INIT_TO_EXIT:
  1221.         fprintf(stderr,
  1222.         "The %s %s%s%s references\n"
  1223.         "a %s %s%s%s.\n"
  1224.         "This is often seen when error handling "
  1225.         "in the init function\n"
  1226.         "uses functionality in the exit path.\n"
  1227.         "The fix is often to remove the %sannotation of\n"
  1228.         "%s%s so it may be used outside an exit section.\n",
  1229.         from, sec2annotation(fromsec), fromsym, from_p,
  1230.         to, sec2annotation(tosec), tosym, to_p,
  1231.         sec2annotation(tosec), tosym, to_p);
  1232.         break;
  1233.     case EXIT_TO_INIT:
  1234.         fprintf(stderr,
  1235.         "The %s %s%s%s references\n"
  1236.         "a %s %s%s%s.\n"
  1237.         "This is often seen when error handling "
  1238.         "in the exit function\n"
  1239.         "uses functionality in the init path.\n"
  1240.         "The fix is often to remove the %sannotation of\n"
  1241.         "%s%s so it may be used outside an init section.\n",
  1242.         from, sec2annotation(fromsec), fromsym, from_p,
  1243.         to, sec2annotation(tosec), tosym, to_p,
  1244.         sec2annotation(tosec), tosym, to_p);
  1245.         break;
  1246.     case EXPORT_TO_INIT_EXIT:
  1247.         fprintf(stderr,
  1248.         "The symbol %s is exported and annotated %s\n"
  1249.         "Fix this by removing the %sannotation of %s "
  1250.         "or drop the export.\n",
  1251.         tosym, sec2annotation(tosec), sec2annotation(tosec), tosym);
  1252.     case NO_MISMATCH:
  1253.         /* To get warnings on missing members */
  1254.         break;
  1255.     }
  1256.     fprintf(stderr, "\n");
  1257. }
  1258.  
  1259. static void check_section_mismatch(const char *modname, struct elf_info *elf,
  1260.                                    Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
  1261. {
  1262.     const char *tosec;
  1263.     enum mismatch mismatch;
  1264.  
  1265.     tosec = sec_name(elf, sym->st_shndx);
  1266.     mismatch = section_mismatch(fromsec, tosec);
  1267.     if (mismatch != NO_MISMATCH) {
  1268.         Elf_Sym *to;
  1269.         Elf_Sym *from;
  1270.         const char *tosym;
  1271.         const char *fromsym;
  1272.  
  1273.         from = find_elf_symbol2(elf, r->r_offset, fromsec);
  1274.         fromsym = sym_name(elf, from);
  1275.         to = find_elf_symbol(elf, r->r_addend, sym);
  1276.         tosym = sym_name(elf, to);
  1277.  
  1278.         /* check whitelist - we may ignore it */
  1279.         if (secref_whitelist(fromsec, fromsym, tosec, tosym)) {
  1280.             report_sec_mismatch(modname, mismatch,
  1281.                fromsec, r->r_offset, fromsym,
  1282.                is_function(from), tosec, tosym,
  1283.                is_function(to));
  1284.         }
  1285.     }
  1286. }
  1287.  
  1288. static unsigned int *reloc_location(struct elf_info *elf,
  1289.                     Elf_Shdr *sechdr, Elf_Rela *r)
  1290. {
  1291.     Elf_Shdr *sechdrs = elf->sechdrs;
  1292.     int section = sechdr->sh_info;
  1293.  
  1294.     return (void *)elf->hdr + sechdrs[section].sh_offset +
  1295.         (r->r_offset - sechdrs[section].sh_addr);
  1296. }
  1297.  
  1298. static int addend_386_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
  1299. {
  1300.     unsigned int r_typ = ELF_R_TYPE(r->r_info);
  1301.     unsigned int *location = reloc_location(elf, sechdr, r);
  1302.  
  1303.     switch (r_typ) {
  1304.     case R_386_32:
  1305.         r->r_addend = TO_NATIVE(*location);
  1306.         break;
  1307.     case R_386_PC32:
  1308.         r->r_addend = TO_NATIVE(*location) + 4;
  1309.         /* For CONFIG_RELOCATABLE=y */
  1310.         if (elf->hdr->e_type == ET_EXEC)
  1311.             r->r_addend += r->r_offset;
  1312.         break;
  1313.     }
  1314.     return 0;
  1315. }
  1316.  
  1317. static int addend_arm_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
  1318. {
  1319.     unsigned int r_typ = ELF_R_TYPE(r->r_info);
  1320.  
  1321.     switch (r_typ) {
  1322.     case R_ARM_ABS32:
  1323.         /* From ARM ABI: (S + A) | T */
  1324.         r->r_addend = (int)(long)
  1325.                       (elf->symtab_start + ELF_R_SYM(r->r_info));
  1326.         break;
  1327.     case R_ARM_PC24:
  1328.         /* From ARM ABI: ((S + A) | T) - P */
  1329.         r->r_addend = (int)(long)(elf->hdr +
  1330.                       sechdr->sh_offset +
  1331.                       (r->r_offset - sechdr->sh_addr));
  1332.         break;
  1333.     default:
  1334.         return 1;
  1335.     }
  1336.     return 0;
  1337. }
  1338.  
  1339. static int addend_mips_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
  1340. {
  1341.     unsigned int r_typ = ELF_R_TYPE(r->r_info);
  1342.     unsigned int *location = reloc_location(elf, sechdr, r);
  1343.     unsigned int inst;
  1344.  
  1345.     if (r_typ == R_MIPS_HI16)
  1346.         return 1;    /* skip this */
  1347.     inst = TO_NATIVE(*location);
  1348.     switch (r_typ) {
  1349.     case R_MIPS_LO16:
  1350.         r->r_addend = inst & 0xffff;
  1351.         break;
  1352.     case R_MIPS_26:
  1353.         r->r_addend = (inst & 0x03ffffff) << 2;
  1354.         break;
  1355.     case R_MIPS_32:
  1356.         r->r_addend = inst;
  1357.         break;
  1358.     }
  1359.     return 0;
  1360. }
  1361.  
  1362. static void section_rela(const char *modname, struct elf_info *elf,
  1363.                          Elf_Shdr *sechdr)
  1364. {
  1365.     Elf_Sym  *sym;
  1366.     Elf_Rela *rela;
  1367.     Elf_Rela r;
  1368.     unsigned int r_sym;
  1369.     const char *fromsec;
  1370.  
  1371.     Elf_Rela *start = (void *)elf->hdr + sechdr->sh_offset;
  1372.     Elf_Rela *stop  = (void *)start + sechdr->sh_size;
  1373.  
  1374.     fromsec = sech_name(elf, sechdr);
  1375.     fromsec += strlen(".rela");
  1376.     /* if from section (name) is know good then skip it */
  1377.     if (check_section(modname, fromsec))
  1378.         return;
  1379.  
  1380.     for (rela = start; rela < stop; rela++) {
  1381.         r.r_offset = TO_NATIVE(rela->r_offset);
  1382. #if KERNEL_ELFCLASS == ELFCLASS64
  1383.         if (elf->hdr->e_machine == EM_MIPS) {
  1384.             unsigned int r_typ;
  1385.             r_sym = ELF64_MIPS_R_SYM(rela->r_info);
  1386.             r_sym = TO_NATIVE(r_sym);
  1387.             r_typ = ELF64_MIPS_R_TYPE(rela->r_info);
  1388.             r.r_info = ELF64_R_INFO(r_sym, r_typ);
  1389.         } else {
  1390.             r.r_info = TO_NATIVE(rela->r_info);
  1391.             r_sym = ELF_R_SYM(r.r_info);
  1392.         }
  1393. #else
  1394.         r.r_info = TO_NATIVE(rela->r_info);
  1395.         r_sym = ELF_R_SYM(r.r_info);
  1396. #endif
  1397.         r.r_addend = TO_NATIVE(rela->r_addend);
  1398.         sym = elf->symtab_start + r_sym;
  1399.         /* Skip special sections */
  1400.         if (sym->st_shndx >= SHN_LORESERVE)
  1401.             continue;
  1402.         check_section_mismatch(modname, elf, &r, sym, fromsec);
  1403.     }
  1404. }
  1405.  
  1406. static void section_rel(const char *modname, struct elf_info *elf,
  1407.                         Elf_Shdr *sechdr)
  1408. {
  1409.     Elf_Sym *sym;
  1410.     Elf_Rel *rel;
  1411.     Elf_Rela r;
  1412.     unsigned int r_sym;
  1413.     const char *fromsec;
  1414.  
  1415.     Elf_Rel *start = (void *)elf->hdr + sechdr->sh_offset;
  1416.     Elf_Rel *stop  = (void *)start + sechdr->sh_size;
  1417.  
  1418.     fromsec = sech_name(elf, sechdr);
  1419.     fromsec += strlen(".rel");
  1420.     /* if from section (name) is know good then skip it */
  1421.     if (check_section(modname, fromsec))
  1422.         return;
  1423.  
  1424.     for (rel = start; rel < stop; rel++) {
  1425.         r.r_offset = TO_NATIVE(rel->r_offset);
  1426. #if KERNEL_ELFCLASS == ELFCLASS64
  1427.         if (elf->hdr->e_machine == EM_MIPS) {
  1428.             unsigned int r_typ;
  1429.             r_sym = ELF64_MIPS_R_SYM(rel->r_info);
  1430.             r_sym = TO_NATIVE(r_sym);
  1431.             r_typ = ELF64_MIPS_R_TYPE(rel->r_info);
  1432.             r.r_info = ELF64_R_INFO(r_sym, r_typ);
  1433.         } else {
  1434.             r.r_info = TO_NATIVE(rel->r_info);
  1435.             r_sym = ELF_R_SYM(r.r_info);
  1436.         }
  1437. #else
  1438.         r.r_info = TO_NATIVE(rel->r_info);
  1439.         r_sym = ELF_R_SYM(r.r_info);
  1440. #endif
  1441.         r.r_addend = 0;
  1442.         switch (elf->hdr->e_machine) {
  1443.         case EM_386:
  1444.             if (addend_386_rel(elf, sechdr, &r))
  1445.                 continue;
  1446.             break;
  1447.         case EM_ARM:
  1448.             if (addend_arm_rel(elf, sechdr, &r))
  1449.                 continue;
  1450.             break;
  1451.         case EM_MIPS:
  1452.             if (addend_mips_rel(elf, sechdr, &r))
  1453.                 continue;
  1454.             break;
  1455.         }
  1456.         sym = elf->symtab_start + r_sym;
  1457.         /* Skip special sections */
  1458.         if (sym->st_shndx >= SHN_LORESERVE)
  1459.             continue;
  1460.         check_section_mismatch(modname, elf, &r, sym, fromsec);
  1461.     }
  1462. }
  1463.  
  1464. /**
  1465.  * A module includes a number of sections that are discarded
  1466.  * either when loaded or when used as built-in.
  1467.  * For loaded modules all functions marked __init and all data
  1468.  * marked __initdata will be discarded when the module has been intialized.
  1469.  * Likewise for modules used built-in the sections marked __exit
  1470.  * are discarded because __exit marked function are supposed to be called
  1471.  * only when a module is unloaded which never happens for built-in modules.
  1472.  * The check_sec_ref() function traverses all relocation records
  1473.  * to find all references to a section that reference a section that will
  1474.  * be discarded and warns about it.
  1475.  **/
  1476. static void check_sec_ref(struct module *mod, const char *modname,
  1477.                           struct elf_info *elf)
  1478. {
  1479.     int i;
  1480.     Elf_Shdr *sechdrs = elf->sechdrs;
  1481.  
  1482.     /* Walk through all sections */
  1483.     for (i = 0; i < elf->hdr->e_shnum; i++) {
  1484.         /* We want to process only relocation sections and not .init */
  1485.         if (sechdrs[i].sh_type == SHT_RELA)
  1486.             section_rela(modname, elf, &elf->sechdrs[i]);
  1487.         else if (sechdrs[i].sh_type == SHT_REL)
  1488.             section_rel(modname, elf, &elf->sechdrs[i]);
  1489.     }
  1490. }
  1491.  
  1492. static void get_markers(struct elf_info *info, struct module *mod)
  1493. {
  1494.     const Elf_Shdr *sh = &info->sechdrs[info->markers_strings_sec];
  1495.     const char *strings = (const char *) info->hdr + sh->sh_offset;
  1496.     const Elf_Sym *sym, *first_sym, *last_sym;
  1497.     size_t n;
  1498.  
  1499.     if (!info->markers_strings_sec)
  1500.         return;
  1501.  
  1502.     /*
  1503.      * First count the strings.  We look for all the symbols defined
  1504.      * in the __markers_strings section named __mstrtab_*.  For
  1505.      * these local names, the compiler puts a random .NNN suffix on,
  1506.      * so the names don't correspond exactly.
  1507.      */
  1508.     first_sym = last_sym = NULL;
  1509.     n = 0;
  1510.     for (sym = info->symtab_start; sym < info->symtab_stop; sym++)
  1511.         if (ELF_ST_TYPE(sym->st_info) == STT_OBJECT &&
  1512.             sym->st_shndx == info->markers_strings_sec &&
  1513.             !strncmp(info->strtab + sym->st_name,
  1514.                  "__mstrtab_", sizeof "__mstrtab_" - 1)) {
  1515.             if (first_sym == NULL)
  1516.                 first_sym = sym;
  1517.             last_sym = sym;
  1518.             ++n;
  1519.         }
  1520.  
  1521.     if (n == 0)
  1522.         return;
  1523.  
  1524.     /*
  1525.      * Now collect each name and format into a line for the output.
  1526.      * Lines look like:
  1527.      *    marker_name    vmlinux    marker %s format %d
  1528.      * The format string after the second \t can use whitespace.
  1529.      */
  1530.     mod->markers = NOFAIL(malloc(sizeof mod->markers[0] * n));
  1531.     mod->nmarkers = n;
  1532.  
  1533.     n = 0;
  1534.     for (sym = first_sym; sym <= last_sym; sym++)
  1535.         if (ELF_ST_TYPE(sym->st_info) == STT_OBJECT &&
  1536.             sym->st_shndx == info->markers_strings_sec &&
  1537.             !strncmp(info->strtab + sym->st_name,
  1538.                  "__mstrtab_", sizeof "__mstrtab_" - 1)) {
  1539.             const char *name = strings + sym->st_value;
  1540.             const char *fmt = strchr(name, '\0') + 1;
  1541.             char *line = NULL;
  1542.             asprintf(&line, "%s\t%s\t%s\n", name, mod->name, fmt);
  1543.             NOFAIL(line);
  1544.             mod->markers[n++] = line;
  1545.         }
  1546. }
  1547.  
  1548. static void read_symbols(char *modname)
  1549. {
  1550.     const char *symname;
  1551.     char *version;
  1552.     char *license;
  1553.     struct module *mod;
  1554.     struct elf_info info = { };
  1555.     Elf_Sym *sym;
  1556.  
  1557.     if (!parse_elf(&info, modname))
  1558.         return;
  1559.  
  1560.     mod = new_module(modname);
  1561.  
  1562.     /* When there's no vmlinux, don't print warnings about
  1563.      * unresolved symbols (since there'll be too many ;) */
  1564.     if (is_vmlinux(modname)) {
  1565.         have_vmlinux = 1;
  1566.         mod->skip = 1;
  1567.     }
  1568.  
  1569.     license = get_modinfo(info.modinfo, info.modinfo_len, "license");
  1570.     if (info.modinfo && !license && !is_vmlinux(modname))
  1571.         warn("modpost: missing MODULE_LICENSE() in %s\n"
  1572.              "see include/linux/module.h for "
  1573.              "more information\n", modname);
  1574.     while (license) {
  1575.         if (license_is_gpl_compatible(license))
  1576.             mod->gpl_compatible = 1;
  1577.         else {
  1578.             mod->gpl_compatible = 0;
  1579.             break;
  1580.         }
  1581.         license = get_next_modinfo(info.modinfo, info.modinfo_len,
  1582.                        "license", license);
  1583.     }
  1584.  
  1585.     for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
  1586.         symname = info.strtab + sym->st_name;
  1587.  
  1588.         handle_modversions(mod, &info, sym, symname);
  1589.         handle_moddevtable(mod, &info, sym, symname);
  1590.     }
  1591.     if (!is_vmlinux(modname) ||
  1592.          (is_vmlinux(modname) && vmlinux_section_warnings))
  1593.         check_sec_ref(mod, modname, &info);
  1594.  
  1595.     version = get_modinfo(info.modinfo, info.modinfo_len, "version");
  1596.     if (version)
  1597.         maybe_frob_rcs_version(modname, version, info.modinfo,
  1598.                        version - (char *)info.hdr);
  1599.     if (version || (all_versions && !is_vmlinux(modname)))
  1600.         get_src_version(modname, mod->srcversion,
  1601.                 sizeof(mod->srcversion)-1);
  1602.  
  1603.     get_markers(&info, mod);
  1604.  
  1605.     parse_elf_finish(&info);
  1606.  
  1607.     /* Our trick to get versioning for struct_module - it's
  1608.      * never passed as an argument to an exported function, so
  1609.      * the automatic versioning doesn't pick it up, but it's really
  1610.      * important anyhow */
  1611.     if (modversions)
  1612.         mod->unres = alloc_symbol("struct_module", 0, mod->unres);
  1613. }
  1614.  
  1615. #define SZ 500
  1616.  
  1617. /* We first write the generated file into memory using the
  1618.  * following helper, then compare to the file on disk and
  1619.  * only update the later if anything changed */
  1620.  
  1621. void __attribute__((format(printf, 2, 3))) buf_printf(struct buffer *buf,
  1622.                               const char *fmt, ...)
  1623. {
  1624.     char tmp[SZ];
  1625.     int len;
  1626.     va_list ap;
  1627.  
  1628.     va_start(ap, fmt);
  1629.     len = vsnprintf(tmp, SZ, fmt, ap);
  1630.     buf_write(buf, tmp, len);
  1631.     va_end(ap);
  1632. }
  1633.  
  1634. void buf_write(struct buffer *buf, const char *s, int len)
  1635. {
  1636.     if (buf->size - buf->pos < len) {
  1637.         buf->size += len + SZ;
  1638.         buf->p = realloc(buf->p, buf->size);
  1639.     }
  1640.     strncpy(buf->p + buf->pos, s, len);
  1641.     buf->pos += len;
  1642. }
  1643.  
  1644. static void check_for_gpl_usage(enum export exp, const char *m, const char *s)
  1645. {
  1646.     const char *e = is_vmlinux(m) ?"":".ko";
  1647.  
  1648.     switch (exp) {
  1649.     case export_gpl:
  1650.         fatal("modpost: GPL-incompatible module %s%s "
  1651.               "uses GPL-only symbol '%s'\n", m, e, s);
  1652.         break;
  1653.     case export_unused_gpl:
  1654.         fatal("modpost: GPL-incompatible module %s%s "
  1655.               "uses GPL-only symbol marked UNUSED '%s'\n", m, e, s);
  1656.         break;
  1657.     case export_gpl_future:
  1658.         warn("modpost: GPL-incompatible module %s%s "
  1659.               "uses future GPL-only symbol '%s'\n", m, e, s);
  1660.         break;
  1661.     case export_plain:
  1662.     case export_unused:
  1663.     case export_unknown:
  1664.         /* ignore */
  1665.         break;
  1666.     }
  1667. }
  1668.  
  1669. static void check_for_unused(enum export exp, const char *m, const char *s)
  1670. {
  1671.     const char *e = is_vmlinux(m) ?"":".ko";
  1672.  
  1673.     switch (exp) {
  1674.     case export_unused:
  1675.     case export_unused_gpl:
  1676.         warn("modpost: module %s%s "
  1677.               "uses symbol '%s' marked UNUSED\n", m, e, s);
  1678.         break;
  1679.     default:
  1680.         /* ignore */
  1681.         break;
  1682.     }
  1683. }
  1684.  
  1685. static void check_exports(struct module *mod)
  1686. {
  1687.     struct symbol *s, *exp;
  1688.  
  1689.     for (s = mod->unres; s; s = s->next) {
  1690.         const char *basename;
  1691.         exp = find_symbol(s->name);
  1692.         if (!exp || exp->module == mod)
  1693.             continue;
  1694.         basename = strrchr(mod->name, '/');
  1695.         if (basename)
  1696.             basename++;
  1697.         else
  1698.             basename = mod->name;
  1699.         if (!mod->gpl_compatible)
  1700.             check_for_gpl_usage(exp->export, basename, exp->name);
  1701.         check_for_unused(exp->export, basename, exp->name);
  1702.     }
  1703. }
  1704.  
  1705. /**
  1706.  * Header for the generated file
  1707.  **/
  1708. static void add_header(struct buffer *b, struct module *mod)
  1709. {
  1710.     buf_printf(b, "#include <linux/module.h>\n");
  1711.     buf_printf(b, "#include <linux/vermagic.h>\n");
  1712.     buf_printf(b, "#include <linux/compiler.h>\n");
  1713.     buf_printf(b, "\n");
  1714.     buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n");
  1715.     buf_printf(b, "\n");
  1716.     buf_printf(b, "struct module __this_module\n");
  1717.     buf_printf(b, "__attribute__((section(\".gnu.linkonce.this_module\"))) = {\n");
  1718.     buf_printf(b, " .name = KBUILD_MODNAME,\n");
  1719.     if (mod->has_init)
  1720.         buf_printf(b, " .init = init_module,\n");
  1721.     if (mod->has_cleanup)
  1722.         buf_printf(b, "#ifdef CONFIG_MODULE_UNLOAD\n"
  1723.                   " .exit = cleanup_module,\n"
  1724.                   "#endif\n");
  1725.     buf_printf(b, " .arch = MODULE_ARCH_INIT,\n");
  1726.     buf_printf(b, "};\n");
  1727. }
  1728.  
  1729. void add_staging_flag(struct buffer *b, const char *name)
  1730. {
  1731.     static const char *staging_dir = "drivers/staging";
  1732.  
  1733.     if (strncmp(staging_dir, name, strlen(staging_dir)) == 0)
  1734.         buf_printf(b, "\nMODULE_INFO(staging, \"Y\");\n");
  1735. }
  1736.  
  1737. /**
  1738.  * Record CRCs for unresolved symbols
  1739.  **/
  1740. static int add_versions(struct buffer *b, struct module *mod)
  1741. {
  1742.     struct symbol *s, *exp;
  1743.     int err = 0;
  1744.  
  1745.     for (s = mod->unres; s; s = s->next) {
  1746.         exp = find_symbol(s->name);
  1747.         if (!exp || exp->module == mod) {
  1748.             if (have_vmlinux && !s->weak) {
  1749.                 if (warn_unresolved) {
  1750.                     warn("\"%s\" [%s.ko] undefined!\n",
  1751.                          s->name, mod->name);
  1752.                 } else {
  1753.                     merror("\"%s\" [%s.ko] undefined!\n",
  1754.                               s->name, mod->name);
  1755.                     err = 1;
  1756.                 }
  1757.             }
  1758.             continue;
  1759.         }
  1760.         s->module = exp->module;
  1761.         s->crc_valid = exp->crc_valid;
  1762.         s->crc = exp->crc;
  1763.     }
  1764.  
  1765.     if (!modversions)
  1766.         return err;
  1767.  
  1768.     buf_printf(b, "\n");
  1769.     buf_printf(b, "static const struct modversion_info ____versions[]\n");
  1770.     buf_printf(b, "__used\n");
  1771.     buf_printf(b, "__attribute__((section(\"__versions\"))) = {\n");
  1772.  
  1773.     for (s = mod->unres; s; s = s->next) {
  1774.         if (!s->module)
  1775.             continue;
  1776.         if (!s->crc_valid) {
  1777.             warn("\"%s\" [%s.ko] has no CRC!\n",
  1778.                 s->name, mod->name);
  1779.             continue;
  1780.         }
  1781.         buf_printf(b, "\t{ %#8x, \"%s\" },\n", s->crc, s->name);
  1782.     }
  1783.  
  1784.     buf_printf(b, "};\n");
  1785.  
  1786.     return err;
  1787. }
  1788.  
  1789. static void add_depends(struct buffer *b, struct module *mod,
  1790.             struct module *modules)
  1791. {
  1792.     struct symbol *s;
  1793.     struct module *m;
  1794.     int first = 1;
  1795.  
  1796.     for (m = modules; m; m = m->next)
  1797.         m->seen = is_vmlinux(m->name);
  1798.  
  1799.     buf_printf(b, "\n");
  1800.     buf_printf(b, "static const char __module_depends[]\n");
  1801.     buf_printf(b, "__used\n");
  1802.     buf_printf(b, "__attribute__((section(\".modinfo\"))) =\n");
  1803.     buf_printf(b, "\"depends=");
  1804.     for (s = mod->unres; s; s = s->next) {
  1805.         const char *p;
  1806.         if (!s->module)
  1807.             continue;
  1808.  
  1809.         if (s->module->seen)
  1810.             continue;
  1811.  
  1812.         s->module->seen = 1;
  1813.         p = strrchr(s->module->name, '/');
  1814.         if (p)
  1815.             p++;
  1816.         else
  1817.             p = s->module->name;
  1818.         buf_printf(b, "%s%s", first ? "" : ",", p);
  1819.         first = 0;
  1820.     }
  1821.     buf_printf(b, "\";\n");
  1822. }
  1823.  
  1824. static void add_srcversion(struct buffer *b, struct module *mod)
  1825. {
  1826.     if (mod->srcversion[0]) {
  1827.         buf_printf(b, "\n");
  1828.         buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n",
  1829.                mod->srcversion);
  1830.     }
  1831. }
  1832.  
  1833. static void write_if_changed(struct buffer *b, const char *fname)
  1834. {
  1835.     char *tmp;
  1836.     FILE *file;
  1837.     struct stat st;
  1838.  
  1839.     file = fopen(fname, "r");
  1840.     if (!file)
  1841.         goto write;
  1842.  
  1843.     if (fstat(fileno(file), &st) < 0)
  1844.         goto close_write;
  1845.  
  1846.     if (st.st_size != b->pos)
  1847.         goto close_write;
  1848.  
  1849.     tmp = NOFAIL(malloc(b->pos));
  1850.     if (fread(tmp, 1, b->pos, file) != b->pos)
  1851.         goto free_write;
  1852.  
  1853.     if (memcmp(tmp, b->p, b->pos) != 0)
  1854.         goto free_write;
  1855.  
  1856.     free(tmp);
  1857.     fclose(file);
  1858.     return;
  1859.  
  1860.  free_write:
  1861.     free(tmp);
  1862.  close_write:
  1863.     fclose(file);
  1864.  write:
  1865.     file = fopen(fname, "w");
  1866.     if (!file) {
  1867.         perror(fname);
  1868.         exit(1);
  1869.     }
  1870.     if (fwrite(b->p, 1, b->pos, file) != b->pos) {
  1871.         perror(fname);
  1872.         exit(1);
  1873.     }
  1874.     fclose(file);
  1875. }
  1876.  
  1877. /* parse Module.symvers file. line format:
  1878.  * 0x12345678<tab>symbol<tab>module[[<tab>export]<tab>something]
  1879.  **/
  1880. static void read_dump(const char *fname, unsigned int kernel)
  1881. {
  1882.     unsigned long size, pos = 0;
  1883.     void *file = grab_file(fname, &size);
  1884.     char *line;
  1885.  
  1886.     if (!file)
  1887.         /* No symbol versions, silently ignore */
  1888.         return;
  1889.  
  1890.     while ((line = get_next_line(&pos, file, size))) {
  1891.         char *symname, *modname, *d, *export, *end;
  1892.         unsigned int crc;
  1893.         struct module *mod;
  1894.         struct symbol *s;
  1895.  
  1896.         if (!(symname = strchr(line, '\t')))
  1897.             goto fail;
  1898.         *symname++ = '\0';
  1899.         if (!(modname = strchr(symname, '\t')))
  1900.             goto fail;
  1901.         *modname++ = '\0';
  1902.         if ((export = strchr(modname, '\t')) != NULL)
  1903.             *export++ = '\0';
  1904.         if (export && ((end = strchr(export, '\t')) != NULL))
  1905.             *end = '\0';
  1906.         crc = strtoul(line, &d, 16);
  1907.         if (*symname == '\0' || *modname == '\0' || *d != '\0')
  1908.             goto fail;
  1909.         mod = find_module(modname);
  1910.         if (!mod) {
  1911.             if (is_vmlinux(modname))
  1912.                 have_vmlinux = 1;
  1913.             mod = new_module(NOFAIL(strdup(modname)));
  1914.             mod->skip = 1;
  1915.         }
  1916.         s = sym_add_exported(symname, mod, export_no(export));
  1917.         s->kernel    = kernel;
  1918.         s->preloaded = 1;
  1919.         sym_update_crc(symname, mod, crc, export_no(export));
  1920.     }
  1921.     return;
  1922. fail:
  1923.     fatal("parse error in symbol dump file\n");
  1924. }
  1925.  
  1926. /* For normal builds always dump all symbols.
  1927.  * For external modules only dump symbols
  1928.  * that are not read from kernel Module.symvers.
  1929.  **/
  1930. static int dump_sym(struct symbol *sym)
  1931. {
  1932.     if (!external_module)
  1933.         return 1;
  1934.     if (sym->vmlinux || sym->kernel)
  1935.         return 0;
  1936.     return 1;
  1937. }
  1938.  
  1939. static void write_dump(const char *fname)
  1940. {
  1941.     struct buffer buf = { };
  1942.     struct symbol *symbol;
  1943.     int n;
  1944.  
  1945.     for (n = 0; n < SYMBOL_HASH_SIZE ; n++) {
  1946.         symbol = symbolhash[n];
  1947.         while (symbol) {
  1948.             if (dump_sym(symbol))
  1949.                 buf_printf(&buf, "0x%08x\t%s\t%s\t%s\n",
  1950.                     symbol->crc, symbol->name,
  1951.                     symbol->module->name,
  1952.                     export_str(symbol->export));
  1953.             symbol = symbol->next;
  1954.         }
  1955.     }
  1956.     write_if_changed(&buf, fname);
  1957. }
  1958.  
  1959. static void add_marker(struct module *mod, const char *name, const char *fmt)
  1960. {
  1961.     char *line = NULL;
  1962.     asprintf(&line, "%s\t%s\t%s\n", name, mod->name, fmt);
  1963.     NOFAIL(line);
  1964.  
  1965.     mod->markers = NOFAIL(realloc(mod->markers, ((mod->nmarkers + 1) *
  1966.                              sizeof mod->markers[0])));
  1967.     mod->markers[mod->nmarkers++] = line;
  1968. }
  1969.  
  1970. static void read_markers(const char *fname)
  1971. {
  1972.     unsigned long size, pos = 0;
  1973.     void *file = grab_file(fname, &size);
  1974.     char *line;
  1975.  
  1976.     if (!file)        /* No old markers, silently ignore */
  1977.         return;
  1978.  
  1979.     while ((line = get_next_line(&pos, file, size))) {
  1980.         char *marker, *modname, *fmt;
  1981.         struct module *mod;
  1982.  
  1983.         marker = line;
  1984.         modname = strchr(marker, '\t');
  1985.         if (!modname)
  1986.             goto fail;
  1987.         *modname++ = '\0';
  1988.         fmt = strchr(modname, '\t');
  1989.         if (!fmt)
  1990.             goto fail;
  1991.         *fmt++ = '\0';
  1992.         if (*marker == '\0' || *modname == '\0')
  1993.             goto fail;
  1994.  
  1995.         mod = find_module(modname);
  1996.         if (!mod) {
  1997.             mod = new_module(NOFAIL(strdup(modname)));
  1998.             mod->skip = 1;
  1999.         }
  2000.         if (is_vmlinux(modname)) {
  2001.             have_vmlinux = 1;
  2002.             mod->skip = 0;
  2003.         }
  2004.  
  2005.         if (!mod->skip)
  2006.             add_marker(mod, marker, fmt);
  2007.     }
  2008.     return;
  2009. fail:
  2010.     fatal("parse error in markers list file\n");
  2011. }
  2012.  
  2013. static int compare_strings(const void *a, const void *b)
  2014. {
  2015.     return strcmp(*(const char **) a, *(const char **) b);
  2016. }
  2017.  
  2018. static void write_markers(const char *fname)
  2019. {
  2020.     struct buffer buf = { };
  2021.     struct module *mod;
  2022.     size_t i;
  2023.  
  2024.     for (mod = modules; mod; mod = mod->next)
  2025.         if ((!external_module || !mod->skip) && mod->markers != NULL) {
  2026.             /*
  2027.              * Sort the strings so we can skip duplicates when
  2028.              * we write them out.
  2029.              */
  2030.             qsort(mod->markers, mod->nmarkers,
  2031.                   sizeof mod->markers[0], &compare_strings);
  2032.             for (i = 0; i < mod->nmarkers; ++i) {
  2033.                 char *line = mod->markers[i];
  2034.                 buf_write(&buf, line, strlen(line));
  2035.                 while (i + 1 < mod->nmarkers &&
  2036.                        !strcmp(mod->markers[i],
  2037.                            mod->markers[i + 1]))
  2038.                     free(mod->markers[i++]);
  2039.                 free(mod->markers[i]);
  2040.             }
  2041.             free(mod->markers);
  2042.             mod->markers = NULL;
  2043.         }
  2044.  
  2045.     write_if_changed(&buf, fname);
  2046. }
  2047.  
  2048. struct ext_sym_list {
  2049.     struct ext_sym_list *next;
  2050.     const char *file;
  2051. };
  2052.  
  2053. int main(int argc, char **argv)
  2054. {
  2055.     struct module *mod;
  2056.     struct buffer buf = { };
  2057.     char *kernel_read = NULL, *module_read = NULL;
  2058.     char *dump_write = NULL;
  2059.     char *markers_read = NULL;
  2060.     char *markers_write = NULL;
  2061.     int opt;
  2062.     int err;
  2063.     struct ext_sym_list *extsym_iter;
  2064.     struct ext_sym_list *extsym_start = NULL;
  2065.  
  2066.     while ((opt = getopt(argc, argv, "i:I:e:cmsSo:awM:K:")) != -1) {
  2067.         switch (opt) {
  2068.         case 'i':
  2069.             kernel_read = optarg;
  2070.             break;
  2071.         case 'I':
  2072.             module_read = optarg;
  2073.             external_module = 1;
  2074.             break;
  2075.         case 'c':
  2076.             cross_build = 1;
  2077.             break;
  2078.         case 'e':
  2079.             external_module = 1;
  2080.             extsym_iter =
  2081.                NOFAIL(malloc(sizeof(*extsym_iter)));
  2082.             extsym_iter->next = extsym_start;
  2083.             extsym_iter->file = optarg;
  2084.             extsym_start = extsym_iter;
  2085.             break;
  2086.         case 'm':
  2087.             modversions = 1;
  2088.             break;
  2089.         case 'o':
  2090.             dump_write = optarg;
  2091.             break;
  2092.         case 'a':
  2093.             all_versions = 1;
  2094.             break;
  2095.         case 's':
  2096.             vmlinux_section_warnings = 0;
  2097.             break;
  2098.         case 'S':
  2099.             sec_mismatch_verbose = 0;
  2100.             break;
  2101.         case 'w':
  2102.             warn_unresolved = 1;
  2103.             break;
  2104.             case 'M':
  2105.                 markers_write = optarg;
  2106.                 break;
  2107.             case 'K':
  2108.                 markers_read = optarg;
  2109.                 break;
  2110.         default:
  2111.             exit(1);
  2112.         }
  2113.     }
  2114.  
  2115.     if (kernel_read)
  2116.         read_dump(kernel_read, 1);
  2117.     if (module_read)
  2118.         read_dump(module_read, 0);
  2119.     while (extsym_start) {
  2120.         read_dump(extsym_start->file, 0);
  2121.         extsym_iter = extsym_start->next;
  2122.         free(extsym_start);
  2123.         extsym_start = extsym_iter;
  2124.     }
  2125.  
  2126.     while (optind < argc)
  2127.         read_symbols(argv[optind++]);
  2128.  
  2129.     for (mod = modules; mod; mod = mod->next) {
  2130.         if (mod->skip)
  2131.             continue;
  2132.         check_exports(mod);
  2133.     }
  2134.  
  2135.     err = 0;
  2136.  
  2137.     for (mod = modules; mod; mod = mod->next) {
  2138.         char fname[strlen(mod->name) + 10];
  2139.  
  2140.         if (mod->skip)
  2141.             continue;
  2142.  
  2143.         buf.pos = 0;
  2144.  
  2145.         add_header(&buf, mod);
  2146.         add_staging_flag(&buf, mod->name);
  2147.         err |= add_versions(&buf, mod);
  2148.         add_depends(&buf, mod, modules);
  2149.         add_moddevtable(&buf, mod);
  2150.         add_srcversion(&buf, mod);
  2151.  
  2152.         sprintf(fname, "%s.mod.c", mod->name);
  2153.         write_if_changed(&buf, fname);
  2154.     }
  2155.  
  2156.     if (dump_write)
  2157.         write_dump(dump_write);
  2158.     if (sec_mismatch_count && !sec_mismatch_verbose)
  2159.         warn("modpost: Found %d section mismatch(es).\n"
  2160.              "To see full details build your kernel with:\n"
  2161.              "'make CONFIG_DEBUG_SECTION_MISMATCH=y'\n",
  2162.              sec_mismatch_count);
  2163.  
  2164.     if (markers_read)
  2165.         read_markers(markers_read);
  2166.  
  2167.     if (markers_write)
  2168.         write_markers(markers_write);
  2169.  
  2170.     return err;
  2171. }
  2172.